/*
 * 原版接口
 */
import * as server from "@minecraft/server";
/*
 * 蛋白石数据
 */
import * as data_format from "../data/format";
import * as data_prompt from "../data/prompt";
import * as data_entity from "../data/entity";
import * as data_story from "../data/story";
/*
 * 蛋白石组件
 */
import * as power_property from "./power_property";
import * as native_tools from "./native_tools";
import * as achieve_plan from "./achieve_plan";
import * as math_tools from "./math_tools";
/*
 * 导出模块
 */
export {
    // 释放背包并销毁实体
    UnloadInventoryAndPackage,
    UnloadInventoryAndDestroy,
    // 播放召唤动画
    CompleteSummonAnimation,
    ParticleSummonAnimation,
    // 执行情报获取 
    DisplayChunkBoundary,
    AnalysisWeight,
    GetTargetIntel,
    // 播报特定信息
    NumberParticleDisplay,
    FloatingTextDisplay,
    AlterMessageNotify,
    ErrorMessage,
    PlayPrompt,
    // 使能许可
    IsEnable,
    IsErupt,
};
/**
 * * 判断 实体是否暴击
 * 
 * @param {server.Entity | server.Player} object - 实例对象
 * 
 * @returns {boolean} - 返回 实体是否暴击
 */
function IsErupt(object: server.Entity | server.Player): boolean {
    /**
     * * 获取 实体属性
     */
    const getData = power_property.GetProperty(object);
    /**
     * * 暴击概率
     */
    const eruptOdds = getData.erupt_odds + getData.raise_erupt_odds;
    // 判断 实体属性
    return IsEnable(eruptOdds);
};
/**
 * * 判断 是否启用
 * 
 * @param {number} input - 百分比(整数)
 * 
 * @returns {boolean} - 返回 是否启用
 */
function IsEnable(input: number): boolean {
    // 判断 实体属性
    return math_tools.Random({ min: 0, max: 100 }) <= input;
};
/**
 * * 解析 权重信息
 * 
 * @param input - 带有权重的原始数据
 * 
 * @returns {WEIGHT_INTEL} - 解析后的权重信息
 */
function AnalysisWeight(input: Map<string, number>): WEIGHT_INTEL {
    /**
     * * 带有 权重信息 的 原始数据
     */
    const proto = [...input];
    /**
     * * 获取 原始数据 的 总权重
     */
    const scale = proto.reduce((acc, cur) => acc + cur[1], -1);
    /**
     * * 解析后的目标数组
     */
    const source: string[] = [];
    /**
     * * 随机索引
     */
    const index = math_tools.Random({ min: 0, max: scale }, true);
    // 遍历 原始数据
    proto.forEach(info => { for (let index = 0; index < info[1]; index++) source.push(info[0]) });
    // 返回 解析结果
    return { source, index, output: source[index] };
};
/**
 * * 显示数值粒子效果
 * 
 * @param {data_format.LOCATION_AND_DIMENSION} source - 坐标与维度
 * 
 * @param {number} input - 显示的数值
 * 
 * @param {server.Vector3} offset - 偏移量
 */
function NumberParticleDisplay(source: data_format.LOCATION_AND_DIMENSION, input: number, offset: server.Vector3) {
    // 判断 数值 是否过大
    if (input > 99999) return;
    /**
     * * 粒子参数
     */
    const molang = new server.MolangVariableMap();
    /**
     * * 粒子颜色
     */
    const RGB: server.RGB[] = [...data_story.rune_color.values()];
    /**
     * * 粒子数值
     */
    const intel = input.toString().split('').reverse().map(value => parseInt(value, 10));
    /**
     * * 随机色彩索引
     */
    const index = math_tools.Random({ min: 0, max: RGB.length - 1 }, true);
    // 设置 粒子属性
    molang.setVector3('variable.offset', math_tools.Vector.add(offset, { x: Math.random() - 0.5, y: Math.random() - 0.5, z: Math.random() - 0.5 }));
    molang.setColorRGB('variable.color', RGB[index]);
    // 显示 数值粒子效果
    intel.forEach(
        (value, index) => {
            molang.setVector3('variable.property', { x: value, y: index, z: intel.length });
            native_tools.TrySpawnParticle(source.dimension, 'scripts:setting.number_display', source.location, molang);
        }
    )
};
/**
 * * 包含 粒子动画 与 镜头动画 的 完整召唤动画
 * 
 * @param {server.Player} player - 玩家对象
 * 
 * @param {server.Vector3} location - 召唤点坐标
 */
function CompleteSummonAnimation(player: server.Player, location: server.Vector3) {
    /**
     * * 定义 相机参数
     */
    const camera = player.camera;
    // 构建 粒子动画
    ParticleSummonAnimation(player, location);
    // 构建 镜头动画
    camera.setCamera('minecraft:free', { location: math_tools.Vector.add(location, { x: 15, y: 35, z: 15 }), facingLocation: location, easeOptions: { easeTime: 2 } });
    server.system.runTimeout(() => camera.setCamera('minecraft:free', { location: math_tools.Vector.add(location, { x: -15, y: 5, z: 15 }), facingLocation: location, easeOptions: { easeTime: 2 } }), 80);
    server.system.runTimeout(() => camera.fade({ fadeColor: { red: 0, green: 0, blue: 0 }, fadeTime: { fadeInTime: 1, fadeOutTime: 0.5, holdTime: 0.5 } }), 120);
    server.system.runTimeout(() => camera.setCamera('minecraft:free', { location, facingLocation: location, easeOptions: { easeTime: 1 } }), 120);
    server.system.runTimeout(() => camera.clear(), 140);
};
/**
 * * 通用召唤效果的粒子动画部分
 * 
 * @param {server.Player} player - 玩家对象
 * 
 * @param {server.Vector3} location - 召唤点坐标
 */
function ParticleSummonAnimation(player: server.Player, location: server.Vector3) {
    /**
     * * 定义 粒子参数
     */
    const molang = new server.MolangVariableMap();
    // 构建 动画效果
    molang.setFloat('variable.size', 10);
    molang.setFloat('variable.direction', 3);
    player.spawnParticle('scripts:path_round', location, molang);
    player.spawnParticle('scripts:path_diamond', location, molang);
    player.spawnParticle('scripts:path_butterfly', location, molang);
    molang.setFloat('variable.size', 13);
    player.spawnParticle('scripts:path_round', location, molang);
    server.system.runTimeout(
        () => {
            molang.setFloat('variable.type', 0);
            molang.setVector3('variable.direction', math_tools.Vector.CONSTANT_UP);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: 5, y: 0, z: 0 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: -5, y: 0, z: 0 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: 0, y: 0, z: 5 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: 0, y: 0, z: -5 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: 3.725, y: 0, z: 3.725 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: -3.725, y: 0, z: -3.725 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: -3.725, y: 0, z: 3.725 }), molang);
            player.spawnParticle('scripts:path_ray', math_tools.Vector.add(location, { x: 3.725, y: 0, z: -3.725 }), molang);
            player.playSound('conduit.attack', { volume: 10, location: math_tools.Vector.add(location, { x: 15, y: 35, z: 15 }) });
        }, 40
    );
};
/**
 * * 返回 选中目标 的 信息
 * 
 * @param {server.Entity | server.Player} object - 执行 目标选择 的 实体单位
 * 
 * @returns {server.RawMessage[]} 状态信息
 */
function GetTargetIntel(object: server.Entity | server.Player): server.RawMessage[] {
    /** 
     * * 获取 实体对象
     */
    const entity = object.getEntitiesFromViewDirection()[0]?.entity;
    /** 
     * * 获取 方块对象
     */
    const block = object.getBlockFromViewDirection()?.block;
    /** 
     * * 适配游戏的信息格式
     */
    const message: server.RawMessage[] = [];
    // 检测实体是否存在
    if (entity && entity.isValid()) {
        // 确认实体是否为物品
        if (entity.typeId != 'minecraft:item') return GetEntityIntel(entity, message);
        /** 
         * * 获取 物品对象
         */
        const item = entity.getComponent('minecraft:item')?.itemStack;
        // 确认 物品是否存在
        if (!item) return [{ text: '§4 未知物品 §r' }];
        // 获取 物品信息
        return GetItemStackIntel(item, message);
    }
    // 检测方块是否存在
    else if (block && block.isValid()) return GetBlockIntel(block, message);
    // 确认 目标是否为空
    return [{ text: '§4 未知目标 §r' }];
};
/**
 * * 返回 目标标签 的 排列结果
 * 
 * @param object - 输入的 目标对象
 * 
 * @returns {server.RawMessage[]} - 返回的排列结果
 */
function GetTargetTags(object: server.Entity | server.Block | server.ItemStack): server.RawMessage[] {
    return object.getTags().map(info => { return { text: info + '\n' } });
};
/**
 * * 返回 方块状态对象的排列结果
 * 
 * @param {Record<string, boolean | number | string>} states - 输入的方块状态对象
 * 
 * @returns {server.RawMessage[]} - 返回的排列结果
 */
function GetBlockRecord(states: Record<string, boolean | number | string>): server.RawMessage[] {
    // 设定 各项参数
    let [output, name, value]: [server.RawMessage[], string[], any[]] = [[], [], []]
    // 解析 方块排列 信息
    for (let index in states) {
        value.push(states[index]);
        name.push(index);
    };
    for (let α = 0; α < name.length; α++) {
        output.push({ text: `§r§l<§r§5 ${name[α]} §7:§2 ${value[α]} §r§l>§r\n` });
    };
    //返回 方块排列 信息
    return output;
};
/**
 * * 返回 容器对象的排列结果
 * 
 * @param {server.Container | undefined} container - 输入的容器对象
 * 
 * @param {server.RawMessage[]} message - 输入的排列信息
 */
function GetInventoryIntel(container: server.Container | undefined, message: server.RawMessage[]) {
    // 遍历 库存容器
    if (container) for (let index = 0; index < container.size; index++) {
        /**
         * * 容器物品
         */
        const item = container.getItem(index);
        if (!item) continue;
        message.push(native_tools.ItemTranslate(item), { text: `§r : §2${item.amount}§r\n` });
    };
};
/**
 * * 返回 物品对象的排列结果
 * 
 * @param {server.ItemStack} item - 输入的物品对象
 * 
 * @param {server.RawMessage[]} message - 输入的排列信息
 * 
 * @returns {server.RawMessage[]} - 返回的排列结果
 */
function GetItemStackIntel(item: server.ItemStack, message: server.RawMessage[]): server.RawMessage[] {
    /**
     * * 获取 物品耐久
     */
    const durability = item.getComponent('minecraft:durability');
    /** 
     * * 设定基础文本
     */
    const info: server.RawMessage[] = [
        { text: '§5§o§l[§9 物品 §5]§r : ' },
        native_tools.ItemTranslate(item),
        { text: ' → ' },
        { text: item.typeId },
        { text: `\n\n§5§o§l[§9 数量 §5]§r : ${item.amount}` },
        { text: `\n\n§5§o§l[§9 耐久 §5]§r : ${durability?.damage ?? 0}/${durability?.maxDurability ?? 0}` },
        { text: '\n\n§5§o§l[§9 标签 §5]§r :\n' }
    ];
    //写入信息文本
    message.push(...info, ...GetTargetTags(item));
    // 输出文本信息
    return message;
};
/**
 * * 返回 实体对象的排列结果
 * 
 * @param {server.Entity} entity - 输入的实体对象
 * 
 * @param {server.RawMessage[]} message - 输入的排列信息
 * 
 * @returns {server.RawMessage[]} - 返回的排列结果
 */
function GetEntityIntel(entity: server.Entity, message: server.RawMessage[]): server.RawMessage[] {
    /** 
     * * 获取 实体血量
     */
    const getHealth = entity.getComponent('minecraft:health');
    /** 
     * * 获取 基础移速
     */
    const getBasisSpeed = entity.getComponent('minecraft:movement');
    /** 
     * * 获取 栓绳组件
     */
    const getisTether = entity.getComponent('minecraft:leashable');
    /** 
     * * 获取 驯服组件
     */
    const getTameable = entity.getComponent('minecraft:tameable');
    /** 
     * * 获取 熔岩移速
     */
    const getMagmaSpeed = entity.getComponent('minecraft:lava_movement');
    /** 
     * * 获取 水下移速
     */
    const getWaterSpeed = entity.getComponent('minecraft:underwater_movement');
    /** 
     * * 获取 全部组件标识
     */
    const getAllComponentsID: server.RawMessage[] = entity.getComponents().map(info => [{ text: info.typeId + '\n' }][0])
    /** 
     * * 获取 驯服材料列表
     */
    const getTameItems: server.RawMessage[] = getTameable ? getTameable.getTameItems.map(info => { return { rawtext: [{ text: '\n' }, native_tools.ItemTranslate(info)] } }) : [{ text: '\n' }];
    /** 
     * * 设定基础文本
     */
    const info: server.RawMessage[] = [
        { text: '§5§o§l[§9 实体 §5]§r : ' },
        native_tools.EntityTranslate(entity),
        { text: ' → ' },
        { text: entity.typeId },
        { text: `\n\n§5§o§l[§9 位置 §5]§r : §n${math_tools.Vector.toString(entity.location)}§r` },
        { text: `\n\n§5§o§l[§9 血量 §5]§r : §2${getHealth?.currentValue ?? 0}/${getHealth?.defaultValue ?? 0}§r` },
        { text: `\n\n§5§o§l[§9 能否栓绳 §5]§r : §6${!!getisTether}§r` },
        { text: `\n\n§5§o§l[§9 陆地移速 §5]§r : §2${Math.floor((getBasisSpeed?.defaultValue ?? 0) * 100) / 100}§r` },
        { text: `\n\n§5§o§l[§9 水下移速 §5]§r : §2${Math.floor((getWaterSpeed?.defaultValue ?? 0) * 100) / 100}§r` },
        { text: `\n\n§5§o§l[§9 熔岩移速 §5]§r : §2${Math.floor((getMagmaSpeed?.defaultValue ?? 0) * 100) / 100}§r` },
        { text: '\n\n§5§o§l[§9 驯服材料 §5]§r : §6' },
    ];
    /**
     * * 实体背包
     */
    const container = entity.getComponent('inventory')?.container;
    /**
     * * 背包库存
     */
    const inventory: server.RawMessage[] = [{ text: '§5§o§l[§9 背包 §5]§r :\n' }];
    // 遍历 实体背包
    GetInventoryIntel(container, inventory);
    //写入信息文本
    message.push(...info, ...getTameItems, { text: '\n§5§o§l[§9 标签 §5]§r :\n' }, ...GetTargetTags(entity), { text: '\n§5§o§l[§9 组件 §5]§r:\n' }, ...getAllComponentsID, ...inventory);
    // 返回信息文本
    return message;
};
/**
 * * 返回 方块对象的排列结果
 * 
 * @param block - 输入的方块对象
 * 
 * @param {server.RawMessage[]} message - 输入的排列信息
 * 
 * @returns {server.RawMessage[]} - 返回的排列结果
 */
function GetBlockIntel(block: server.Block, message: server.RawMessage[]): server.RawMessage[] {
    /** 
     * * 获取方块状态
     */
    const states: Record<string, string | number | boolean> = block.permutation.getAllStates();
    /** 
     * * 设定基础文本
     */
    const info: server.RawMessage[] = [
        { text: '§5§o§l[§9 方块 §5]§r : ' },
        native_tools.BlockTranslate(block),
        { text: ' → ' },
        { text: block.typeId },
        { text: `\n\n§5§o§l[§9 红石能量 §5]§r : §4${block.getRedstonePower() ?? 0}§r` },
        { text: '\n\n§5§o§l[§9 方块状态 §5]§r :\n' },
    ];
    /**
     * * 方块容器
     */
    const container = block.getComponent('inventory')?.container;
    /**
     * * 容器库存
     */
    const inventory: server.RawMessage[] = [{ text: '\n§5§o§l[§9 方块容器 §5]§r :\n' }];
    // 遍历方块容器
    GetInventoryIntel(container, inventory);
    // 写入信息文本
    message.push(...info, ...GetBlockRecord(states), { text: '\n§5§o§l[§9 方块标签 §5]§r :\n' }, ...GetTargetTags(block), ...inventory);
    // 输出文本信息
    return message;
};
/**
 * * 显示引导提示
 * 
 * @param {server.Player} object - 显示引导提示的玩家对象
 * 
 * @param {string} type - 指引类型
 */
function PlayPrompt(object: server.Player, type: string) {
    /**
     * * 指引文本
     */
    const intel = data_prompt.entry.get(type);
    /**
     * * 引导提示开头
     */
    const message: server.RawMessage = { text: '「 星之引导 」: ' };
    // 检测 指引文本 与 玩家身份
    if (object.hasTag('prompt:' + type) || !intel) return;
    // 显示 指引文本
    intel.forEach(info => server.system.runTimeout(() => object.sendMessage([message, info.refer]), info.delay));
    intel.forEach(info => server.system.runTimeout(() => object.playSound('resonate.amethyst_block'), info.delay));
    // 添加识别标签
    object.addTag('prompt:' + type);
};
/**
 * * 卸载 实体背包库存后 封装为 特定物品
 * 
 * @param {server.Entity} target - 进行封装的目标对象
 * 
 * @param {server.Player} player - 发起封装的玩家对象
 * 
 * @param {server.ItemStack} material - 封装材料
 * 
 * @param {string} itemName - 封装物品名称
 * 
 * @param {string[]} itemLore - 封装物品词缀
 */
function UnloadInventoryAndPackage(target: server.Entity, player: server.Player, material: server.ItemStack, itemName: string, itemLore: string[]) {
    // 检测 目标对象 是否为玩家
    if (target instanceof server.Player) return;
    /**
     * * 获取 实体背包
     */
    const container = target.getComponent('inventory')?.container;
    /**
     * * 获取 实体背包库存
     */
    const items: server.ItemStack[] = [];
    /**
     * * 获取 实体 的 动态属性类型数组
     */
    const types = target.getDynamicPropertyIds();
    /**
     * * 获取 实体 的 标签数组
     */
    const tags = target.getTags();
    /**
     * * 复制实体坐标
     */
    const anchor = math_tools.Vector.copy(target.location);
    /**
     * * 获取 实体名称
     */
    const nameTag = target.nameTag.length >= 1 ? target.nameTag : data_entity.name_mapping.get(target.typeId);
    // 无视大小写 根据首字母进行排序
    types.sort((a, b) => a[0].toLowerCase().charCodeAt(0) - b[0].toLowerCase().charCodeAt(0));
    // 清空 目标背包 并缓存 全部物品信息
    if (container) for (let index = 0; index < container.size; index++) {
        /**
         * * 背包物品
         */
        const item = container.getItem(index);
        if (!item) continue;
        items.push(item);
        container.setItem(index);
    };
    // 设置 物品动态属性
    types.forEach(type => material.setDynamicProperty(type, target.getDynamicProperty(type)));
    material.setDynamicProperty('reduction_pureness:tags', JSON.stringify(tags));
    material.setDynamicProperty('reduction_pureness:name', target.nameTag);
    material.setDynamicProperty('reduction_pureness:type', target.typeId);
    // 设置 物品名称
    material.nameTag = itemName + nameTag + '§r';
    // 设置 物品词缀
    material.setLore(itemLore);
    // 给与玩家物品
    server.system.runTimeout(() => { native_tools.TrySpawnItem(player.dimension, material, player.getHeadLocation()) }, 10);
    // 释放背包物品
    server.system.runTimeout(() => { items.forEach(item => native_tools.TrySpawnItem(player.dimension, item, anchor)) }, 10);
    // 销毁目标实体
    target.remove();
};
/**
 * * 卸载 实体背包库存后 销毁实体
 * 
 * @param {server.Entity} target - 进行卸载的目标实体
 */
function UnloadInventoryAndDestroy(target: server.Entity) {
    /**
     * * 获取 实体背包
     */
    const container = target.getComponent('inventory')?.container;
    /**
     * * 获取 实体背包库存
     */
    const items: server.ItemStack[] = [];
    /**
     * * 复制实体坐标
     */
    const location = math_tools.Vector.copy(target.location);
    /**
     * * 复制实体维度
     */
    const dimension = server.world.getDimension(target.dimension.id);
    // 清空 目标背包 并缓存 全部物品信息
    if (container) for (let index = 0; index < container.size; index++) {
        /**
         * * 背包物品
         */
        const item = container.getItem(index);
        if (!item) continue;
        items.push(item);
        container.setItem(index);
    };
    // 释放背包物品
    server.system.runTimeout(() => { items.forEach(item => native_tools.TrySpawnItem(dimension, item, location)) }, 10);
    // 销毁目标实体
    target.remove();
};
/**
 * * 修改 消息通知
 *
 * @param {string} title - 消息通知 的 标题
 * 
 * @param {server.Block | server.Entity | server.Player}  block - 消息通知 的 发信源
 * 
 * @param {server.RawMessage} message - 消息通知 的 文本内容
 */
function AlterMessageNotify(title: string, block: server.Block, message: server.RawMessage) {
    /**
     * * 获得 区块坐标
     */
    const chunkString = math_tools.Vector.toString(math_tools.Vector.chunkLocation(block.location));
    /**
     * * 获得 当前区块的消息通知
     */
    const entry = data_story.message_notify.get(chunkString) ?? new Map<string, server.RawMessage>();
    /**
     * * 编写 发信源信息
     */
    const rawMessage: server.RawMessage = {
        rawtext: [
            { text: '\n| §l§p' },
            { text: block.dimension.id },
            { text: '§r | §a' },
            { text: math_tools.Vector.toString(block.location) },
            { text: '§r |\n\n' },
            message
        ]
    };
    // 编写当前区块的消息通知
    entry.set(title, rawMessage);
    // 将当前区块的 消息通知 写入 数据库
    data_story.message_notify.set(chunkString, entry);
    // 如果是简单的信息 则 显示悬浮字信息
    if (!message.rawtext) FloatingTextDisplay(block, message.text ?? '未知');
};
/**
 * * 显示悬浮字信息
 * 
 * @param {server.Block} block - 显示悬浮字信息的方块
 * 
 * @param {string} text - 悬浮字信息的文本
 */
function FloatingTextDisplay(block: server.Block, text: string) {
    // 移除 信息显示实体
    block.dimension.getEntitiesAtBlockLocation(block.location).forEach(entity => { if (entity.typeId == 'entity_sundry:name_display') entity.remove() });
    // 创建 信息显示实体
    server.system.run(
        () => {
            /**
             * * 创建 信息显示实体
             */
            const entity = native_tools.TrySpawnEntity(block.dimension, 'entity_sundry:name_display', block.bottomCenter());
            // 将数据编写为实体名称
            if (entity instanceof server.Entity) entity.nameTag = text ?? '未知';
        }
    );
};
/**
 * * 处理错误信息
 *
 * @param {string} title - 错误信息 的 标题
 * 
 * @param {server.Block | server.Entity | server.Player}  block - 错误信息 的 发信源
 * 
 * @param {server.RawMessage} message - 错误信息 的 文本内容
 */
function ErrorMessage(title: string, block: server.Block, message: server.RawMessage) {
    /**
     * * 定义 令牌类型
     */
    const type = 'error -> ' + block.typeId;
    /**
     * * 获取令牌
     */
    const token = achieve_plan.ControlEventTrigger.BlockToken(type, block, 40);
    if (!token) return;
    /**
     * * 定义 粒子参数
     */
    const molang = new server.MolangVariableMap();
    // 设置 粒子参数
    molang.setFloat('variable.direction', 3);
    molang.setFloat('variable.size', 3);
    // 显示 发生错误情况 的 粒子效果
    native_tools.TrySpawnParticle(block.dimension, 'scripts:path_comet', block.center(), molang);
    // 发送 发生错误情况 的 消息通知
    AlterMessageNotify(title, block, message);
};
/**
 * * 显示 区块边界
 * 
 * @param {data_format.LOCATION_AND_DIMENSION} source - 用于显示区块边界的 坐标信息与维度信息
 */
function DisplayChunkBoundary(source: data_format.LOCATION_AND_DIMENSION) {
    /**
     * * 校准 锚点信息
     */
    const anchor = math_tools.Vector.add(source.location, { x: 0, y: -16, z: 0 });
    /**
     * * 设定 区块显示 起点坐标
     */
    const startPlace = math_tools.Vector.chunkLocation(anchor, false);
    /**
     * * 设定 区块显示 终点坐标
     */
    const donePlace = math_tools.Vector.add(startPlace, { x: 16, y: 32, z: 16 });
    // 创建 路径执行计划
    achieve_plan.PathExecute.CreateForFrame(
        '显示区块边界',
        {
            particles: ['constant:prompt_route'],
            location_group: [],
            dimension: source.dimension,
            cooldown: 1,
            speed: 1
        },
        startPlace, donePlace
    );
};
/**
 * * 权重信息
 */
interface WEIGHT_INTEL {
    /**
     * * 解析后 展开的 信息数组
     */
    source: string[];
    /**
     * * 解析后 返回的 索引
     */
    index: number;
    /**
     * * 解析后 返回的 值
     */
    output: string;
};